home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 February: Tool Chest / Dev.CD Feb 95 / Dev.CD Feb 95.toast / Tool Chest / Interfaces / Universal Interfaces 2.0a3 / CIncludes / complex.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-14  |  11.7 KB  |  500 lines  |  [TEXT/MPS ]
  1. /*
  2. **      (c) Copyright 1988-1994 by Dyad Software Corp.
  3. **     All Rights Reserved
  4. **
  5. **      Authors: lwd, geb
  6. **
  7. **    Some portions Copyright © 1994 Apple Computer Inc.
  8. */
  9.  
  10.  
  11. #ifndef __COMPLEX__
  12. #define __COMPLEX__
  13.  
  14. #ifndef __FP__
  15. #include <fp.h>
  16. #endif
  17.  
  18. #ifndef FLT_TYPE
  19. #define FLT_TYPE long double
  20. #endif
  21.  
  22. #ifndef   powerc              /*   preserve compatibility with 68k macintoshes    */
  23. #define   cLog    clog
  24. #endif
  25.  
  26. #ifdef __cplusplus
  27.  
  28. class ostream;
  29. class istream;
  30.  
  31.  
  32. class complex
  33. {
  34.  
  35.  public:
  36.    friend FLT_TYPE real ( const complex& );     
  37.    friend FLT_TYPE imag ( const complex& );     
  38.  
  39.    friend complex cos ( const complex& );
  40.    friend complex cosh ( const complex& );
  41.    friend complex sin ( const complex& );
  42.    friend complex sinh ( const complex& );
  43.    friend complex tan ( const complex& );
  44.    friend complex tanh ( const complex& );
  45.    friend complex log ( const complex& );
  46.    friend complex log10 ( const complex& );
  47.    friend complex sqrt ( const complex& );
  48.    friend FLT_TYPE abs ( const complex& );
  49.    friend complex conj ( const complex& );
  50.    friend FLT_TYPE norm ( const complex& );
  51.    friend FLT_TYPE modulus ( const complex& );
  52.    friend FLT_TYPE arg ( const complex& );
  53.    friend complex asin ( const complex& );
  54.    friend complex acos ( const complex& );
  55.    friend complex atan ( const complex& );
  56.    friend complex asinh ( const complex& );
  57.    friend complex atanh ( const complex& );
  58.    friend complex exp ( const complex& );
  59.    friend complex polar ( FLT_TYPE r, FLT_TYPE theta = 0);
  60.  
  61.    friend complex operator + ( const complex&, const complex& );
  62.    friend complex operator + ( FLT_TYPE, const complex& );
  63.    friend complex operator + ( const complex&, FLT_TYPE );
  64.  
  65.    friend complex operator - ( const complex&, const complex& );
  66.    friend complex operator - ( FLT_TYPE, const complex& );
  67.    friend complex operator - ( const complex&, FLT_TYPE );
  68.  
  69.    friend complex operator * ( const complex&, const complex& );
  70.    friend complex operator * ( FLT_TYPE, const complex& );
  71.    friend complex operator * ( const complex&, FLT_TYPE );
  72.  
  73.    friend complex operator / ( const complex&, const complex& );
  74.    friend complex operator / ( FLT_TYPE, const complex& );
  75.    friend complex operator / ( const complex&, FLT_TYPE );
  76.  
  77.    friend complex pow( const complex& lhs, FLT_TYPE rhs );
  78.    friend complex pow( const complex& lhs, const complex & rhs );
  79.    friend complex pow( FLT_TYPE lhs, const complex & rhs);
  80.    friend complex pow( const complex& lhs, int rhs);
  81.  
  82.    friend int operator && ( const complex&, const complex& );
  83.    friend int operator && ( FLT_TYPE, const complex& );
  84.    friend int operator && ( const complex&, FLT_TYPE );
  85.  
  86.    friend int operator || ( const complex&, const complex& );
  87.    friend int operator || ( FLT_TYPE, const complex& );
  88.    friend int operator || ( const complex&, FLT_TYPE );
  89.  
  90.    friend int operator != ( const complex&, const complex& );
  91.    friend int operator != ( FLT_TYPE, const complex& );
  92.    friend int operator != ( const complex&, FLT_TYPE );
  93.  
  94.    friend int operator == ( const complex&, const complex& );
  95.    friend int operator == ( FLT_TYPE, const complex& );
  96.    friend int operator == ( const complex&, FLT_TYPE );
  97.  
  98.    friend ostream& operator << ( ostream& s, const complex& x);
  99.    friend istream& operator >> ( istream& s, complex& x);
  100.  
  101.  public:
  102.  
  103.    complex ( );
  104.    complex ( FLT_TYPE r, FLT_TYPE i ); /*   this is not declared (FLT_TYPE r, FLT_TYPE i = 0)
  105.                                         to avoid implicit conversion. Binary operations
  106.                                         are explicitly declared thus avoiding potential 
  107.                                         ambiguities. */
  108.    complex ( const complex & );   
  109.    FLT_TYPE& real ( );
  110.    FLT_TYPE& imag ( );
  111.    
  112.    complex& operator = ( const complex& );
  113.    complex& operator = ( FLT_TYPE );
  114.    
  115.    complex& operator += ( const complex& );
  116.    complex& operator += ( FLT_TYPE );
  117.    
  118.    complex& operator -= ( const complex& );
  119.    complex& operator -= ( FLT_TYPE );
  120.    
  121.    complex& operator *= ( const complex& );
  122.    complex& operator *= ( FLT_TYPE );
  123.    
  124.    complex& operator /= ( const complex& );
  125.    complex& operator /= ( FLT_TYPE );
  126.    
  127.    int operator ! () const;
  128.    complex operator - () const;
  129.    
  130.  private:
  131.    FLT_TYPE re;
  132.    FLT_TYPE im;
  133.  };
  134.  
  135. inline complex::complex ( )
  136. {
  137. #if 0
  138.   /* remove these comments for initialization to (0,0)
  139.      re = im = 0; 
  140.      */
  141. #else
  142.     re = im = NAN;
  143. #endif
  144. }
  145.  
  146. inline complex::complex ( FLT_TYPE r, FLT_TYPE i ): re(r), im(i) {}
  147.      inline complex::complex( const complex& z)
  148. {
  149.   re = z.re;
  150.   im = z.im;
  151. }    
  152.  
  153. inline FLT_TYPE real ( const complex& z){ return z.re; }     
  154. inline FLT_TYPE imag ( const complex& z){ return z.im; }
  155.      
  156. inline FLT_TYPE& complex::real (){ return re; }     
  157. inline FLT_TYPE& complex::imag (){ return im; }
  158.      
  159. /* operator + */
  160. inline complex operator + ( const complex& lhs, const complex& rhs )
  161. {
  162.   return  complex ( lhs.re + rhs.re, lhs.im + rhs.im );
  163. }
  164. inline complex operator + ( FLT_TYPE  lhs, const complex& rhs )
  165. {
  166.   return  complex ( lhs + rhs.re, rhs.im );
  167. }
  168. inline complex operator + ( const complex& lhs, FLT_TYPE rhs )
  169. {
  170.   return  complex ( lhs.re + rhs, lhs.im );
  171. }
  172.  
  173. /* operator - */
  174. inline complex operator - ( const complex& lhs, const complex& rhs )
  175. {
  176.   return  complex ( lhs.re - rhs.re, lhs.im - rhs.im );
  177. }
  178. inline complex operator - ( FLT_TYPE lhs, const complex& rhs )
  179. {
  180.   return  complex ( lhs - rhs.re, - rhs.im );
  181. }
  182. inline complex operator - ( const complex& lhs, FLT_TYPE rhs )
  183. {
  184.   return  complex ( lhs.re - rhs, lhs.im );
  185. }
  186.  
  187. /* operator * */
  188. inline complex operator * ( const complex& lhs, const complex& rhs )
  189. {
  190.   return  complex ( lhs.re * rhs.re - lhs.im * rhs.im, 
  191.            lhs.re * rhs.im + lhs.im*rhs.re );
  192. }
  193. inline complex operator * ( FLT_TYPE lhs, const complex& rhs )
  194. {
  195.   return  complex ( lhs * rhs.re, lhs * rhs.im );
  196. }
  197. inline complex operator * ( const complex& lhs, FLT_TYPE rhs )
  198. {
  199.   return  complex ( lhs.re * rhs, lhs.im*rhs );
  200. }
  201.  
  202. /* operator / */
  203.  
  204. inline complex operator / ( const complex& lhs, FLT_TYPE rhs )
  205. {
  206.   return complex( lhs.re / rhs, lhs.im /rhs );
  207. }
  208.  
  209. /* unary operators */
  210. inline complex complex::operator - ( ) const
  211. {
  212.   return  complex ( -re, -im );
  213. }
  214.  
  215. inline int complex::operator ! ( )  const
  216. {
  217.   return  ( re == 0 ) && ( im == 0 ) ;
  218. }    
  219.  
  220.  
  221. inline complex & complex::operator = ( const complex& z)
  222. {
  223.   re = z.re;
  224.   im = z.im;
  225.   return  *this;
  226. }    
  227.  
  228. inline complex & complex::operator = ( FLT_TYPE x)
  229. {
  230.   re = x;
  231.   im = 0;
  232.   return  *this;
  233. }    
  234.  
  235. /* operator *= */
  236. inline complex & complex::operator *= ( const complex& z)
  237. {
  238.   *this = *this * z;
  239.   return  *this;
  240. }
  241. inline complex & complex::operator *= ( FLT_TYPE x )
  242. {
  243.   re *= x;
  244.   im *= x;
  245.   return  *this;
  246. }
  247.  
  248. inline complex & complex::operator /= ( const complex& z)
  249. {
  250.   *this = *this / z;
  251.   return  *this;
  252. }    
  253. inline complex & complex::operator /= ( FLT_TYPE x)
  254. {
  255.   re /= x;
  256.   im /= x;
  257.   return  *this;
  258. }    
  259.  
  260. inline complex & complex::operator += ( const complex& z)
  261. {
  262.   re += z.re;
  263.   im += z.im;
  264.   return  *this;
  265. }
  266. inline complex & complex::operator += ( FLT_TYPE x)
  267. {
  268.   re += x;
  269.   return  *this;
  270. }
  271.  
  272. inline complex & complex::operator -= ( const complex& z)
  273. {
  274.   re -= z.re;
  275.   im -= z.im;
  276.   return  *this;
  277. }
  278.  
  279. inline complex & complex::operator -= ( FLT_TYPE x)
  280. {
  281.   re -= x;
  282.   return  *this;
  283. }    
  284.  
  285. /* operator && */
  286. inline int operator && ( const complex & lhs, const complex & rhs )
  287. {
  288.   return  (( lhs.re != 0 ) || ( lhs.im != 0 )) &&
  289.     (( rhs.re != 0 ) || ( rhs.im != 0 )) ;
  290. }    
  291. inline int operator && ( FLT_TYPE lhs, const complex & rhs )
  292. {
  293.   return  ( lhs != 0 ) && (( rhs.re != 0 ) || ( rhs.im != 0 )) ;
  294. }    
  295. inline int operator && ( const complex & lhs, FLT_TYPE rhs )
  296. {
  297.   return  (( lhs.re != 0 ) || ( lhs.im != 0 )) && ( rhs != 0 ) ;
  298. }    
  299.  
  300. /* operator || */
  301. inline int operator || ( const complex & lhs, const complex & rhs )
  302. {
  303.   return  (( lhs.re != 0 ) || ( lhs.im != 0 )) ||
  304.     (( rhs.re != 0 ) || ( rhs.im != 0 )) ;
  305. }
  306. inline int operator || ( FLT_TYPE lhs, const complex & rhs )
  307. {
  308.   return  ( lhs != 0 ) || (( rhs.re != 0 ) || ( rhs.im != 0 )) ;
  309. }
  310. inline int operator || ( const complex & lhs, FLT_TYPE rhs )
  311. {
  312.   return  (( lhs.re != 0 ) || ( lhs.im != 0 )) || ( rhs != 0 );
  313. }    
  314.  
  315. /* operator != */
  316. inline  int operator != ( const complex& lhs, const complex& rhs )
  317. {
  318.   return  ( lhs.re != rhs.re ) || ( lhs.im != rhs.im );
  319. }
  320. inline  int operator != ( FLT_TYPE lhs, const complex& rhs )
  321. {
  322.   return  ( lhs != rhs.re ) || ( 0 != rhs.im );
  323. }
  324. inline  int operator != ( const complex& lhs, FLT_TYPE rhs )
  325. {
  326.   return  ( lhs.re != rhs ) || ( lhs.im != 0 );
  327. }
  328.  
  329. /* operator == */
  330. inline  int operator == ( const complex& lhs, const complex& rhs )
  331. {
  332.   return  ( lhs.re == rhs.re ) && ( lhs.im == rhs.im );
  333. }
  334. inline  int operator == ( FLT_TYPE lhs, const complex& rhs )
  335. {
  336.   return  ( lhs == rhs.re ) && ( 0 == rhs.im );
  337. }
  338. inline  int operator == ( const complex& lhs, FLT_TYPE rhs )
  339. {
  340.   return  ( lhs.re == rhs ) && ( lhs.im == 0 );
  341. }
  342.  
  343. inline FLT_TYPE arg( const complex& z)
  344. {
  345.   return atan2(z.im,z.re);
  346. }
  347.  
  348. inline complex atanh( const complex& z) 
  349. {
  350.   complex iz(-z.im, z.re);
  351.   complex ix = atan(iz);
  352.   return complex ( ix.im, -ix.re);
  353. }
  354.  
  355. inline complex asinh( const complex& z)
  356. {
  357.   complex iz(-z.im, z.re);
  358.   complex ix = asin(iz);
  359.   return complex ( ix.im, -ix.re);
  360. }
  361.  
  362. inline FLT_TYPE norm( const complex& z)
  363. {
  364.   return z.re*z.re + z.im*z.im;
  365. }
  366.  
  367. inline FLT_TYPE modulus( const complex& z)
  368. {
  369.   return abs(z);
  370. }
  371.  
  372. inline complex conj( const complex& z)
  373. {
  374.   return complex( z.re, -z.im );
  375. }
  376.  
  377. inline complex cos( const complex& z )
  378. {
  379.   return complex( cos(z.re) * cosh( z.im ),  -( sin( z.re) * sinh(z.im)));
  380. }
  381.  
  382. inline complex cosh( const complex& z )
  383. {
  384.   return complex ( cosh(z.re) * cos(z.im), sinh(z.re) * sin(z.im) );
  385. }
  386.  
  387. inline complex sin( const complex& z )
  388. {
  389.   return complex ( sin(z.re) * cosh(z.im), cos(z.re) * sinh(z.im) );
  390. }
  391.  
  392. inline complex sinh( const complex& z )
  393. {
  394.   return complex ( sinh(z.re) * cos(z.im), cosh(z.re) * sin(z.im) );
  395. }
  396.  
  397. inline complex tan( const complex& z )
  398. {
  399.   FLT_TYPE x = 2*z.re;
  400.   FLT_TYPE y = 2*z.im;
  401.   FLT_TYPE t = 1.0/(cos(x) +cosh(y));
  402.   
  403.   return complex( t*sin(x), t*sinh(y) );
  404. }
  405.  
  406. inline complex tanh( const complex& z )
  407. {
  408.   FLT_TYPE x = 2*z.re;
  409.   FLT_TYPE y = 2*z.im;
  410.   FLT_TYPE t = 1.0/(cosh(x) +cos(y));
  411.   
  412.   return complex( t*sinh(x), t*sin(y) );
  413. }    
  414.  
  415. inline complex exp( const complex& z )
  416. {
  417.   FLT_TYPE x = exp(z.re);
  418.   return complex( x*cos(z.im), x*sin(z.im) );
  419. }    
  420.  
  421. inline complex log( const complex& z )
  422. {
  423.   return complex( log( abs(z) ), arg( z ) );
  424. }    
  425.  
  426. inline complex log10( const complex& z )
  427. {
  428.   return complex( 0.2171472409516259*log( norm(z) ), arg( z ) );
  429. }    
  430.  
  431. inline complex polar ( FLT_TYPE r, FLT_TYPE theta )
  432. {
  433.   return complex ( r * cos(theta), r * sin(theta));
  434. }
  435.  
  436. #else    /* __cplusplus */
  437.  
  438. /* Standard ANSI C version of complex.h */
  439.  
  440. struct complex {
  441.     double_t    re;
  442.     double_t    im;
  443. };
  444.  
  445. typedef struct complex complex;
  446.  
  447. #endif    /* __cplusplus */
  448.  
  449. #ifdef __cplusplus
  450. extern "C" {
  451. #endif
  452.  
  453. /* Standard ANSI complex functions */
  454.  
  455. complex cadd( complex x, complex y );
  456. complex csub( complex x, complex y );
  457. complex cmul( complex x, complex y );
  458. complex cdiv( complex x, complex y );
  459. complex xdivc( double_t x, complex y );
  460. complex csqrt( complex z );
  461. complex csin( complex z );
  462. complex ccos( complex z );
  463. complex csquare( complex z );
  464. complex cexp( complex z );
  465. complex cLog( complex z );
  466. complex cepwry( double_t x, complex y );
  467. complex cxpwri( complex x, long y );
  468. complex cxpwre( complex x, double_t y );
  469. complex cxpwry( complex x, complex y );
  470. complex csinh( complex z );
  471. complex ccosh( complex z );
  472. complex ctanh( complex z );
  473. complex ctan( complex z );
  474. complex casin( complex z );
  475. complex casinh( complex z );
  476. complex cacos( complex z );
  477. complex cacosh( complex z );
  478. complex catan( complex z );
  479. complex catanh( complex z );
  480. complex cconj( complex z );
  481.  
  482. double_t cabs( complex z );
  483. double_t carg( complex z );
  484.  
  485. #ifdef __cplusplus
  486. }    // close the extern "C" declaration
  487. #endif
  488.  
  489. #endif
  490.  
  491.  
  492.  
  493.  
  494.  
  495.  
  496.  
  497.  
  498.  
  499.  
  500.